import './axios.min.js';

/**
 * 创建 axios 实例
 * @type {AxiosInstance}
 */
const service = axios.create({
    baseURL: 'http://localhost:8888',
    timeout: 5000,
    headers: {
        'Content-Type': 'application/json;charset=UTF-8',
        // 'X-Requested-With': 'XMLHttpRequest'
    }
});

// 请求拦截器
service.interceptors.request.use(
    config => {
        // 在发送请求之前做些什么
        console.log('请求拦截器', config);

        // 示例：添加token
        const token = localStorage.getItem('token') || 'demo-token';
        if (token) {
            config.headers['Authorization'] = `Bearer ${token}`;
        }

        return config;
    },
    error => {
        // 对请求错误做些什么
        console.error('请求错误:', error);
        return Promise.reject(error);
    }
);

// 响应拦截器
service.interceptors.response.use(
    response => {
        // 对响应数据做点什么
        console.log('响应拦截器', response);

        // 示例：只返回data部分
        return response.data;
    },
    error => {
        // 对响应错误做点什么
        console.error('响应错误:', error);

        if (error.response) {
            // 服务器返回了错误状态码
            switch (error.response.status) {
                case 400:
                    error.message = '请求错误(400)';
                    break;
                case 401:
                    error.message = '未授权，请重新登录(401)';
                    // 可以跳转到登录页面
                    break;
                case 403:
                    error.message = '拒绝访问(403)';
                    break;
                case 404:
                    error.message = '请求资源不存在(404)';
                    break;
                case 500:
                    error.message = '服务器错误(500)';
                    break;
                case 502:
                    error.message = '网络错误(502)';
                    break;
                case 503:
                    error.message = '服务不可用(503)';
                    break;
                case 504:
                    error.message = '网络超时(504)';
                    break;
                default:
                    error.message = `连接错误(${error.response.status})`;
            }
        } else if (error.request) {
            // 请求已发出，但没有收到响应
            error.message = '网络连接异常，请检查网络';
        } else {
            // 设置请求时发生了一些事情，触发了一个错误
            error.message = '请求出错，请重试';
        }

        // 可以在这里统一显示错误提示
        // alert(error.message);

        return Promise.reject(error);
    }
);

/**
 * 封装请求方法
 */
const http = {
    /**
     * GET 请求
     * @param {string} url 
     * @param {object} params 
     * @param {object} config 
     * @returns {Promise}
     */
    get(url, params = {}, config = {}) {
        return service({
            url,
            method: 'GET',
            params,
            ...config
        });
    },

    /**
     * POST 请求
     * @param {string} url 
     * @param {object} data 
     * @param {object} config 
     * @returns {Promise}
     */
    post(url, data = {}, config = {}) {
        return service({
            url,
            method: 'POST',
            data,
            ...config
        });
    },

    /**
     * PUT 请求
     * @param {string} url 
     * @param {object} data 
     * @param {object} config 
     * @returns {Promise}
     */
    put(url, data = {}, config = {}) {
        return service({
            url,
            method: 'PUT',
            data,
            ...config
        });
    },

    /**
     * DELETE 请求
     * @param {string} url 
     * @param {object} data 
     * @param {object} config 
     * @returns {Promise}
     */
    delete(url, data = {}, config = {}) {
        return service({
            url,
            method: 'DELETE',
            data,
            ...config
        });
    },

    /**
     * 文件上传
     * @param {string} url 
     * @param {FormData} formData 
     * @param {Function} onUploadProgress 
     * @param {object} config 
     * @returns {Promise}
     */
    upload(url, formData, onUploadProgress, config = {}) {
        return service({
            url,
            method: 'POST',
            data: formData,
            headers: {
                'Content-Type': 'multipart/form-data',
                ...config.headers
            },
            onUploadProgress,
            ...config
        });
    },

    /**
     * 发送 FormData 格式数据
     * @param {string} url 
     * @param {object} formData 
     * @param {object} config 
     * @returns {Promise}
     */
    form(url, formData, config = {}) {
        const data = new FormData();
        Object.keys(formData).forEach(key => {
            data.append(key, formData[key]);
        });

        return service({
            url,
            method: 'POST',
            data,
            headers: {
                'Content-Type': 'multipart/form-data',
                ...config.headers
            },
            ...config
        });
    },

    /**
     * 发送 URLSearchParams 格式数据
     * @param {string} url 
     * @param {object} params 
     * @param {object} config 
     * @returns {Promise}
     */
    formUrlEncoded(url, params, config = {}) {
        const data = new URLSearchParams();
        Object.keys(params).forEach(key => {
            data.append(key, params[key]);
        });

        return service({
            url,
            method: 'POST',
            data,
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
                ...config.headers
            },
            ...config
        });
    },

    /**
     * 发送纯文本数据
     * @param {string} url 
     * @param {string} text 
     * @param {object} config 
     * @returns {Promise}
     */
    text(url, text, config = {}) {
        return service({
            url,
            method: 'POST',
            data: text,
            headers: {
                'Content-Type': 'text/plain',
                ...config.headers
            },
            ...config
        });
    },

    /**
     * 发送 Blob 数据
     * @param {string} url 
     * @param {Blob} blob 
     * @param {object} config 
     * @returns {Promise}
     */
    blob(url, blob, config = {}) {
        return service({
            url,
            method: 'POST',
            data: blob,
            headers: {
                'Content-Type': blob.type || 'application/octet-stream',
                ...config.headers
            },
            ...config
        });
    },

    /**
     * 发送 ArrayBuffer 数据
     * @param {string} url 
     * @param {ArrayBuffer} arrayBuffer 
     * @param {object} config 
     * @returns {Promise}
     */
    arrayBuffer(url, arrayBuffer, config = {}) {
        return service({
            url,
            method: 'POST',
            data: arrayBuffer,
            headers: {
                'Content-Type': 'application/octet-stream',
                ...config.headers
            },
            ...config
        });
    },

    /**
     * 发送自定义格式数据
     * @param {string} url 
     * @param {*} data 
     * @param {string} contentType 
     * @param {object} config 
     * @returns {Promise}
     */
    custom(url, data, contentType, config = {}) {
        return service({
            url,
            method: 'POST',
            data,
            headers: {
                'Content-Type': contentType,
                ...config.headers
            },
            ...config
        });
    }
};

export default http;